package bccsp

//所有已经实现的操作集合
const (
	// ECDSA椭圆曲线数字签名算法(key gen, import, sign, verify),
	// 默认的安全级别 256
	// 每个BCCSP可能支持或不支持默认安全级别。如果不支持，则返回eroor。
	ECDSA = "ECDSA"
	// ECDSAP256 256位的椭圆加密算法
	ECDSAP256 = "ECDSAP256"
	// ECDSAP384 384位的椭圆加密算法
	ECDSAP384 = "ECDSAP384"
	// ECDSAReRand ECDSA 秘钥重新随机化
	ECDSAReRand = "ECDSA_RERAND"

	// 默认安全等级的AES加密算法
	// 在每个BCCSP中如果不支持默认安全等级，则会返回一个error
	AES = "AES"
	// 128位的AES
	AES128 = "AES128"
	// 192位的AES
	AES192 = "AES192"
	// 256位的AES
	AES256 = "AES256"

	// HMAC keyed-hash消息验证码
	HMAC = "HMAC"
	// 被截取到256位的 HMAC keyed-hash消息验证码
	HMACTruncated256 = "HMAC_TRUNCATED_256"

	// 使用默认协议簇的SHA hash算法
	// 每个BCCSP可能支持或不支持默认安全级别。如果不支持，则返回eroor。
	SHA = "SHA"
	// SHA2
	SHA2 = "SHA2"
	// SHA3
	SHA3 = "SHA3"
	// SHA256
	SHA256 = "SHA256"
	// SHA384
	SHA384 = "SHA384"
	// SHA3_256
	SHA3_256 = "SHA3_256"
	// SHA3_384
	SHA3_384 = "SHA3_384"

	// X509 certificate X509证书相关操作标签
	X509Certificate = "X509Certificate"
)

// ECDSAKeyGenOpts包含ECDSA密钥生成选项。
type ECDSAKeyGenOpts struct {
	// 是否是暂时的
	Temporary bool
}

// 返回ECDSA标识
func (opts *ECDSAKeyGenOpts) Algorithm() string {
	return ECDSA
}

// 返回秘钥key产生是否是暂时的
func (opts *ECDSAKeyGenOpts) Ephemeral() bool {
	return opts.Temporary
}

// ECDSAPKIXPublicKeyImportOpts 是PKIX格式的ECDSA公钥import选项
type ECDSAPKIXPublicKeyImportOpts struct {
	//临时的
	Temporary bool
}

// 返回ECDSAPKIXPublicKeyImport所对应的算法名称
func (opts *ECDSAPKIXPublicKeyImportOpts) Algorithm() string {
	return ECDSA
}

// 返回ECDSAPKIXPublicKeyImportOpts是否是暂时的
func (opts *ECDSAPKIXPublicKeyImportOpts) Ephemeral() bool {
	return opts.Temporary
}

// ECDSAPrivateKeyImportOpts 是ECDSA密钥的import ,DER格式 或者 pkcs#8格式。
type ECDSAPrivateKeyImportOpts struct {
	Temporary bool
}

// ECDSAPrivateKeyImportOpts 对应的算法名称
func (opts *ECDSAPrivateKeyImportOpts) Algorithm() string {
	return ECDSA
}

// ECDSAPrivateKeyImportOpts 是否是暂时的
func (opts *ECDSAPrivateKeyImportOpts) Ephemeral() bool {
	return opts.Temporary
}

// 从ecdsa.PublicKey 使用的import算法
type ECDSAGoPublicKeyImportOpts struct {
	Temporary bool
}

// 返回算法名称ECDSA
func (opts *ECDSAGoPublicKeyImportOpts) Algorithm() string {
	return ECDSA
}

// 返回是否是暂时的
func (opts *ECDSAGoPublicKeyImportOpts) Ephemeral() bool {
	return opts.Temporary
}

// ECDSA秘钥重生成opts
type ECDSAReRandKeyOpts struct {
	Temporary bool
	//填充段
	Expansion []byte
}

// 返回ECDSAReRandKeyOpts 所对应的派生key算法名称
func (opts *ECDSAReRandKeyOpts) Algorithm() string {
	return ECDSAReRand
}

// 返回产生的key是否是暂时的
func (opts *ECDSAReRandKeyOpts) Ephemeral() bool {
	return opts.Temporary
}

// 返回ECDSAReRandKeyOpts的扩张值
func (opts *ECDSAReRandKeyOpts) ExpansionValue() []byte {
	return opts.Expansion
}

// AESKeyGenOpts 默认安全等级的AES 秘钥产生
type AESKeyGenOpts struct {
	Temporary bool
}

// AESKeyGenOpts 返回AES的算法名称
func (opts *AESKeyGenOpts) Algorithm() string {
	return AES
}

// AESKeyGenOpts 是否是暂时的
func (opts *AESKeyGenOpts) Ephemeral() bool {
	return opts.Temporary
}

// HMACTruncated256AESDeriveKeyOpts包含在256位密钥派生时截断的HMAC选项。
type HMACTruncated256AESDeriveKeyOpts struct {
	Temporary bool
	//参数
	Arg []byte
}

// HMAC 256截断算法名称
func (opts *HMACTruncated256AESDeriveKeyOpts) Algorithm() string {
	return HMACTruncated256
}

// 产生的key是否是暂时的
func (opts *HMACTruncated256AESDeriveKeyOpts) Ephemeral() bool {
	return opts.Temporary
}

// 返回输入的参数
func (opts *HMACTruncated256AESDeriveKeyOpts) Argument() []byte {
	return opts.Arg
}

// HMACD 分配key操作算法
type HMACDeriveKeyOpts struct {
	// 暂时的
	Temporary bool
	// 暂时的
	Arg []byte
}

// HMAC返回算法名称
func (opts *HMACDeriveKeyOpts) Algorithm() string {
	return HMAC
}

// 返回产生的key是否是暂时的
func (opts *HMACDeriveKeyOpts) Ephemeral() bool {
	return opts.Temporary
}

// 返回HMAC的派生key操作参数
func (opts *HMACDeriveKeyOpts) Argument() []byte {
	return opts.Arg
}

// AES256ImportKeyOpts 产生AES256的的import 算法
type AES256ImportKeyOpts struct {
	Temporary bool
}

// AES256ImportKeyOpts 的算法名称
func (opts *AES256ImportKeyOpts) Algorithm() string {
	return AES
}

// AES256ImportKeyOpts 是否是暂时的
func (opts *AES256ImportKeyOpts) Ephemeral() bool {
	return opts.Temporary
}

// HMACImportKeyOpts HMAC的import key算法
type HMACImportKeyOpts struct {
	Temporary bool
}

// HMACImportKeyOpts HMAC算法名称
func (opts *HMACImportKeyOpts) Algorithm() string {
	return HMAC
}

// HMAC import的key是否是暂时的
func (opts *HMACImportKeyOpts) Ephemeral() bool {
	return opts.Temporary
}

// SHAOpts 操作
type SHAOpts struct{}

// SHA操作的算法名称
func (opts *SHAOpts) Algorithm() string {
	return SHA
}

// X509PublicKeyImportOpts 的公钥import算法
type X509PublicKeyImportOpts struct {
	Temporary bool
}

// 返回算法证书的名称
func (opts *X509PublicKeyImportOpts) Algorithm() string {
	return X509Certificate
}

// 返回操作产生的key是否是暂时的
func (opts *X509PublicKeyImportOpts) Ephemeral() bool {
	return opts.Temporary
}
